package com.chenhao.generator.util;

import java.lang.reflect.Field;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 字符串工具
 *
 * @author:chenHao
 * @version:1.0
 * @since:1.0
 * @createTime:2019-10-03
 */
public class StringUtil {
    private static Pattern linePattern = Pattern.compile("_(\\w)");

    private StringUtil() {

    }


    /**
     * 去掉指定字符串的开头的指定字符
     *
     * @param stream 原始字符串
     * @param trim   要删除的字符串
     * @return
     */
    public static String StringStartTrim(String stream, String trim) {
        // null或者空字符串的时候不处理
        if (stream == null || stream.length() == 0 || trim == null || trim.length() == 0) {
            return stream;
        }
        if (stream.startsWith(trim)) {
            stream = stream.substring(trim.length());
        }
        // 返回处理后的字符串
        return stream;

    }


    /**
     * Map里面的key和字符串里面${}里面的名称保持以一致
     *
     * @param template 字符串
     * @param dto      参数
     * @return java.lang.String
     * @author chenHao
     * @date 2019-10-04
     **/
    public static String processTemplate(String template, Object dto) {
        StringBuffer sb = new StringBuffer();
        Map<String, String> params = convertObjToDto(dto);
        Matcher m = Pattern.compile("\\$\\{\\w+\\}").matcher(template);
        while (m.find()) {
            String param = m.group();
            Object value = params.get(param.substring(2, param.length() - 1));
            m.appendReplacement(sb, value == null ? "" : value.toString());
        }
        m.appendTail(sb);
        return sb.toString();
    }

    /**
     * 对象转 map
     *
     * @param obj
     * @return java.util.Map<java.lang.String, java.lang.String>
     * @author chenHao
     * @date 2019-10-04
     **/
    public static Map<String, String> convertObjToDto(Object obj) {
        Map<String, String> dto = new HashMap<>();
        if (obj == null) {
            return null;
        }
        Field[] fields = obj.getClass().getDeclaredFields();
        try {
            for (Field field : fields) {
                try {
                    Field f = obj.getClass().getDeclaredField(field.getName());
                    f.setAccessible(true);
                    Object o = f.get(obj);
                    if (f.getType() == Date.class) {
                        dto.put(field.getName(), "时间格式无效");
                    } else {
                        dto.put(field.getName(), String.valueOf(o));
                    }
                } catch (NoSuchFieldException | IllegalArgumentException | IllegalAccessException e) {
                    e.printStackTrace();
                }
            }
        } catch (SecurityException e) {
            e.printStackTrace();
        }
        return dto;
    }

    /**
     * 格式化domain类名
     *
     * @param tableName
     * @return
     */
    public static String formatDomainName(String tableName) {
        return formatName(tableName);
    }

    /**
     * 格式化get、set方法后半部分
     *
     * @param methodName
     * @return
     */
    public static String formatGetSetMethod(String methodName) {
        return formatName(methodName);
    }

    /**
     * a:首字母大写
     * b:若含有下划线，则去掉下划线，下划线后第一位字母大写
     *
     * @param str
     * @return
     */
    private static String formatName(String str) {
        //首先全部转小写
        str = str.toLowerCase();
        char[] cs = str.toCharArray();
        cs[0] -= 32;
        str = String.valueOf(cs);
        Matcher matcher = linePattern.matcher(str);
        StringBuffer sb = new StringBuffer();
        while (matcher.find()) {
            matcher.appendReplacement(sb, matcher.group(1).toUpperCase());
        }
        matcher.appendTail(sb);
        return sb.toString();

    }

    /**
     * a:首字母小写
     * b:若含有下划线，则去掉下划线，下划线后所有字母大写
     *
     * @param name
     * @return
     */
    public static String formatFieldName(String name) {
        //首先全部转小写
        name = name.toLowerCase();
        StringBuilder result = new StringBuilder();
        // 快速检查
        if (name == null || name.isEmpty()) {
            // 没必要转换
            return "";
        } else if (!name.contains("_")) {
            // 不含下划线，仅将首字母小写
            return name.substring(0, 1).toLowerCase() + name.substring(1);
        }
        // 用下划线将原始字符串分割
        String camels[] = name.split("_");
        for (String camel : camels) {
            // 跳过原始字符串中开头、结尾的下换线或双重下划线
            if (camel.isEmpty()) {
                continue;
            }
            // 处理真正的驼峰片段
            if (result.length() == 0) {
                // 第一个驼峰片段，全部字母都小写
                result.append(camel.toLowerCase());
            } else {
                // 其他的驼峰片段，首字母大写
                result.append(camel.substring(0, 1).toUpperCase());
                result.append(camel.substring(1).toLowerCase());
            }
        }
        return result.toString();

    }
}
